home *** CD-ROM | disk | FTP | other *** search
/ Freelog 100 / FreelogNo100-NovembreDecembre2010.iso / Musique / solfege / solfege-win32-3.17.0.exe / {app} / bin / Lib / bsddb / test / test_compare.py < prev    next >
Text File  |  2005-10-28  |  8KB  |  250 lines
  1. """
  2. TestCases for python DB Btree key comparison function.
  3. """
  4.  
  5. import sys, os, re
  6. import test_all
  7. from cStringIO import StringIO
  8.  
  9. import unittest
  10. try:
  11.     # For Pythons w/distutils pybsddb
  12.     from bsddb3 import db, dbshelve
  13. except ImportError:
  14.     # For Python 2.3
  15.     from bsddb import db, dbshelve
  16.  
  17. lexical_cmp = cmp
  18.  
  19. def lowercase_cmp(left, right):
  20.     return cmp (left.lower(), right.lower())
  21.  
  22. def make_reverse_comparator (cmp):
  23.     def reverse (left, right, delegate=cmp):
  24.         return - delegate (left, right)
  25.     return reverse
  26.  
  27. _expected_lexical_test_data = ['', 'CCCP', 'a', 'aaa', 'b', 'c', 'cccce', 'ccccf']
  28. _expected_lowercase_test_data = ['', 'a', 'aaa', 'b', 'c', 'CC', 'cccce', 'ccccf', 'CCCP']
  29.  
  30. class ComparatorTests (unittest.TestCase):
  31.     def comparator_test_helper (self, comparator, expected_data):
  32.         data = expected_data[:]
  33.         data.sort (comparator)
  34.         self.failUnless (data == expected_data,
  35.                          "comparator `%s' is not right: %s vs. %s"
  36.                          % (comparator, expected_data, data))
  37.     def test_lexical_comparator (self):
  38.         self.comparator_test_helper (lexical_cmp, _expected_lexical_test_data)
  39.     def test_reverse_lexical_comparator (self):
  40.         rev = _expected_lexical_test_data[:]
  41.         rev.reverse ()
  42.         self.comparator_test_helper (make_reverse_comparator (lexical_cmp),
  43.                                      rev)
  44.     def test_lowercase_comparator (self):
  45.         self.comparator_test_helper (lowercase_cmp,
  46.                                      _expected_lowercase_test_data)
  47.  
  48. class AbstractBtreeKeyCompareTestCase (unittest.TestCase):
  49.     env = None
  50.     db = None
  51.  
  52.     def setUp (self):
  53.         self.filename = self.__class__.__name__ + '.db'
  54.         homeDir = os.path.join (os.path.dirname (sys.argv[0]), 'db_home')
  55.         self.homeDir = homeDir
  56.         try:
  57.             os.mkdir (homeDir)
  58.         except os.error:
  59.             pass
  60.  
  61.         env = db.DBEnv ()
  62.         env.open (homeDir,
  63.                   db.DB_CREATE | db.DB_INIT_MPOOL
  64.                   | db.DB_INIT_LOCK | db.DB_THREAD)
  65.         self.env = env
  66.  
  67.     def tearDown (self):
  68.         self.closeDB ()
  69.         if self.env is not None:
  70.             self.env.close ()
  71.             self.env = None
  72.         import glob
  73.         map (os.remove, glob.glob (os.path.join (self.homeDir, '*')))
  74.  
  75.     def addDataToDB (self, data):
  76.         i = 0
  77.         for item in data:
  78.             self.db.put (item, str (i))
  79.             i = i + 1
  80.  
  81.     def createDB (self, key_comparator):
  82.         self.db = db.DB (self.env)
  83.         self.setupDB (key_comparator)
  84.         self.db.open (self.filename, "test", db.DB_BTREE, db.DB_CREATE)
  85.  
  86.     def setupDB (self, key_comparator):
  87.         self.db.set_bt_compare (key_comparator)
  88.  
  89.     def closeDB (self):
  90.         if self.db is not None:
  91.             self.db.close ()
  92.             self.db = None
  93.  
  94.     def startTest (self):
  95.         pass
  96.  
  97.     def finishTest (self, expected = None):
  98.         if expected is not None:
  99.             self.check_results (expected)
  100.         self.closeDB ()
  101.  
  102.     def check_results (self, expected):
  103.         curs = self.db.cursor ()
  104.         try:
  105.             index = 0
  106.             rec = curs.first ()
  107.             while rec:
  108.                 key, ignore = rec
  109.                 self.failUnless (index < len (expected),
  110.                                  "to many values returned from cursor")
  111.                 self.failUnless (expected[index] == key,
  112.                                  "expected value `%s' at %d but got `%s'"
  113.                                  % (expected[index], index, key))
  114.                 index = index + 1
  115.                 rec = curs.next ()
  116.             self.failUnless (index == len (expected),
  117.                              "not enough values returned from cursor")
  118.         finally:
  119.             curs.close ()
  120.  
  121. class BtreeKeyCompareTestCase (AbstractBtreeKeyCompareTestCase):
  122.     def runCompareTest (self, comparator, data):
  123.         self.startTest ()
  124.         self.createDB (comparator)
  125.         self.addDataToDB (data)
  126.         self.finishTest (data)
  127.  
  128.     def test_lexical_ordering (self):
  129.         self.runCompareTest (lexical_cmp, _expected_lexical_test_data)
  130.  
  131.     def test_reverse_lexical_ordering (self):
  132.         expected_rev_data = _expected_lexical_test_data[:]
  133.         expected_rev_data.reverse ()
  134.         self.runCompareTest (make_reverse_comparator (lexical_cmp),
  135.                              expected_rev_data)
  136.  
  137.     def test_compare_function_useless (self):
  138.         self.startTest ()
  139.         def socialist_comparator (l, r):
  140.             return 0
  141.         self.createDB (socialist_comparator)
  142.         self.addDataToDB (['b', 'a', 'd'])
  143.         # all things being equal the first key will be the only key
  144.         # in the database...  (with the last key's value fwiw)
  145.         self.finishTest (['b'])
  146.  
  147.  
  148. class BtreeExceptionsTestCase (AbstractBtreeKeyCompareTestCase):
  149.     def test_raises_non_callable (self):
  150.         self.startTest ()
  151.         self.assertRaises (TypeError, self.createDB, 'abc')
  152.         self.assertRaises (TypeError, self.createDB, None)
  153.         self.finishTest ()
  154.  
  155.     def test_set_bt_compare_with_function (self):
  156.         self.startTest ()
  157.         self.createDB (lexical_cmp)
  158.         self.finishTest ()
  159.  
  160.     def check_results (self, results):
  161.         pass
  162.  
  163.     def test_compare_function_incorrect (self):
  164.         self.startTest ()
  165.         def bad_comparator (l, r):
  166.             return 1
  167.         # verify that set_bt_compare checks that comparator('', '') == 0
  168.         self.assertRaises (TypeError, self.createDB, bad_comparator)
  169.         self.finishTest ()
  170.  
  171.     def verifyStderr(self, method, successRe):
  172.         """
  173.         Call method() while capturing sys.stderr output internally and
  174.         call self.fail() if successRe.search() does not match the stderr
  175.         output.  This is used to test for uncatchable exceptions.
  176.         """
  177.         stdErr = sys.stderr
  178.         sys.stderr = StringIO()
  179.         try:
  180.             method()
  181.         finally:
  182.             temp = sys.stderr
  183.             sys.stderr = stdErr
  184.             errorOut = temp.getvalue()
  185.             if not successRe.search(errorOut):
  186.                 self.fail("unexpected stderr output:\n"+errorOut)
  187.  
  188.     def _test_compare_function_exception (self):
  189.         self.startTest ()
  190.         def bad_comparator (l, r):
  191.             if l == r:
  192.                 # pass the set_bt_compare test
  193.                 return 0
  194.             raise RuntimeError, "i'm a naughty comparison function"
  195.         self.createDB (bad_comparator)
  196.         #print "\n*** test should print 2 uncatchable tracebacks ***"
  197.         self.addDataToDB (['a', 'b', 'c'])  # this should raise, but...
  198.         self.finishTest ()
  199.  
  200.     def test_compare_function_exception(self):
  201.         self.verifyStderr(
  202.                 self._test_compare_function_exception,
  203.                 re.compile('(^RuntimeError:.* naughty.*){2}', re.M|re.S)
  204.         )
  205.  
  206.     def _test_compare_function_bad_return (self):
  207.         self.startTest ()
  208.         def bad_comparator (l, r):
  209.             if l == r:
  210.                 # pass the set_bt_compare test
  211.                 return 0
  212.             return l
  213.         self.createDB (bad_comparator)
  214.         #print "\n*** test should print 2 errors about returning an int ***"
  215.         self.addDataToDB (['a', 'b', 'c'])  # this should raise, but...
  216.         self.finishTest ()
  217.  
  218.     def test_compare_function_bad_return(self):
  219.         self.verifyStderr(
  220.                 self._test_compare_function_bad_return,
  221.                 re.compile('(^TypeError:.* return an int.*){2}', re.M|re.S)
  222.         )
  223.  
  224.  
  225.     def test_cannot_assign_twice (self):
  226.  
  227.         def my_compare (a, b):
  228.             return 0
  229.  
  230.         self.startTest ()
  231.         self.createDB (my_compare)
  232.         try:
  233.             self.db.set_bt_compare (my_compare)
  234.             assert False, "this set should fail"
  235.  
  236.         except RuntimeError, msg:
  237.             pass
  238.  
  239. def test_suite ():
  240.     res = unittest.TestSuite ()
  241.  
  242.     res.addTest (unittest.makeSuite (ComparatorTests))
  243.     if db.version () >= (3, 3, 11):
  244.         res.addTest (unittest.makeSuite (BtreeExceptionsTestCase))
  245.         res.addTest (unittest.makeSuite (BtreeKeyCompareTestCase))
  246.     return res
  247.  
  248. if __name__ == '__main__':
  249.     unittest.main (defaultTest = 'suite')
  250.